{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建方式示例\n",
    "empty_list = []                     # 空列表\n",
    "number_list = [1, 3, 5, 7, 9]       # 整数列表\n",
    "mixed_list = [1, \"二\", True, 4.0]   # 混合类型列表\n",
    "nested_list = [[1,2], [3,4]]        # 嵌套列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# 索引操作演示\n",
    "print(number_list[0])     # 输出第一个元素: 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(number_list[-1])    # 输出倒数第一个元素: 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(nested_list[1][0])  # 输出二维索引: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(nested_list[0][0])  # 输出二维索引: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(nested_list[0][0])  # 输出二维索引: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "逐个元素遍历:\n",
      "1 3 5 7 9 "
     ]
    }
   ],
   "source": [
    "# 遍历方法对比\n",
    "print(\"逐个元素遍历:\")\n",
    "for num in number_list:\n",
    "    print(num, end=' ')   # 输出：1 3 5 7 9 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "索引遍历:\n",
      "索引0: 1\n",
      "索引1: 3\n",
      "索引2: 5\n",
      "索引3: 7\n",
      "索引4: 9\n"
     ]
    }
   ],
   "source": [
    "print(\"索引遍历:\")\n",
    "for i in range(len(number_list)):\n",
    "    print(f\"索引{i}: {number_list[i]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "枚举遍历:\n",
      "0→1\n",
      "1→3\n",
      "2→5\n",
      "3→7\n",
      "4→9\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n枚举遍历:\") # index, value = 0, 1\n",
    "for index, value in enumerate(number_list):\n",
    "    print(f\"{index}→{value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 可变操作演示\n",
    "numbers = [2, 4, 6]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# 增删操作\n",
    "numbers.append(8)            # 末尾添加 → [2,4,6,8]\n",
    "print(numbers)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "numbers.insert(1, 3)         # 索引1插入3 → [2,3,4,6,8]\n",
    "print(numbers)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers.remove(4)            # 删除首个4 → [2,3,6,8]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "popped = numbers.pop(2)      # 删除索引2元素 → 6 \n",
    "print(popped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "# 排序切片\n",
    "numbers.sort(reverse=True)   # 降序 → [8,3,2]\n",
    "print(numbers)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "numbers = [0,1,2,3,4,5,6,7,8,9]\n",
    "sublist = numbers[1:8]       # 切片 → [8,3]\n",
    "print(sublist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "reversed_list = numbers[::-1]  # 逆序 → [2,3,8]\n",
    "print(reversed_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 3, 2, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "numbers = [8,3,2]\n",
    "# 列表运算\n",
    "combined = numbers + [5,7]   # 合并列表 → [8,3,2,5,7]\n",
    "print(combined)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 3, 2, 8, 3, 2, 8, 3, 2, 8, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "doubled = numbers * 4        # 重复元素 → [8,3,2,8,3,2]\n",
    "print(doubled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 6, 12, 20, 30, 42, 56, 72, 90]\n"
     ]
    }
   ],
   "source": [
    "# 生成数值列表\n",
    "squares = [x*(x+1) for x in range(10)]         # [0,1,4,...,81]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "squares = []\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "even_squares = [x**2 for x in range(10) if x%2==0]  # 偶数的平方\n",
    "print(even_squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "even_squares = []\n",
    "for x in range(10):\n",
    "    if x%2==0:\n",
    "        even_squares.append(x**2)\n",
    "print(even_squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵转换\n",
    "matrix = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "flatten = [num for row in matrix for num in row]  # 二维转一维 → [1,2,...,9]\n",
    "print(flatten)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "matrix = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "flatten = []\n",
    "for row in matrix:\n",
    "    for num in row:\n",
    "        flatten.append(num)\n",
    "print(flatten)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['APPLE']\n"
     ]
    }
   ],
   "source": [
    "# 条件过滤\n",
    "words = [\"apple\", \"banana\", \"cherry\"]\n",
    "short_words = [word.upper() for word in words if len(word) < 6]  # [\"APPLE\", \"CHERRY\"]\n",
    "print(short_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['APPLE']\n"
     ]
    }
   ],
   "source": [
    "words = [\"apple\", \"banana\", \"cherry\"]\n",
    "short_words = []\n",
    "for word in words:\n",
    "    if (len(word) < 6):\n",
    "        short_words.append(word.upper())\n",
    "print(short_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20]\n"
     ]
    }
   ],
   "source": [
    "# 多重条件\n",
    "nums = [x for x in range(30) if x%2==0 if x%5==0]  # 同时满足两个条件 → [0,10,20]\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20]\n"
     ]
    }
   ],
   "source": [
    "nums = []\n",
    "for x in range(30):\n",
    "    if x%2 == 0:\n",
    "        if x %5 == 0:\n",
    "            nums.append(x)\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "推导式执行时间: 0.51091929996619\n",
      "普通循环执行时间: 0.6157339999917895\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "\n",
    "# 推导式 vs 循环\n",
    "print(\"推导式执行时间:\",\n",
    "      timeit.timeit('[x**2 for x in range(1000)]', number=10000))\n",
    "\n",
    "print(\"普通循环执行时间:\",\n",
    "      timeit.timeit(\n",
    "          'l=[]\\nfor x in range(1000): l.append(x**2)',\n",
    "          number=10000))\n",
    "\n",
    "# 结果示例：\n",
    "# 推导式执行时间: 0.812秒\n",
    "# 普通循环执行时间: 1.234秒"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建方式对比\n",
    "list_num = [1, 2, 3]  # 列表使用方括号\n",
    "tuple_num = (4, 5, 6)  # 元组使用圆括号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "list_num[0] = 0\n",
    "print(list_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[109], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m tuple_num[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tuple_num[0] = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 字典创建方式\n",
    "empty_dict = {}   # 空字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\"name\": \"Alice\", \"age\": 28}           # 直接定义 {key: value}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person['age']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores = {'张三':80, '李四':90, '小明':100}\n",
    "scores['小明']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "name = ['张三', '李四', '小明']\n",
    "scores = [80,90,100]\n",
    "for i, n in enumerate(name):\n",
    "    if n == '小明':\n",
    "        print(scores[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'id': 1001, 'role': 'admin'}"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_from_tuples = dict([(\"id\", 1001), (\"role\", \"admin\")])  # 元组列表转换\n",
    "dict_from_tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1, 2: 8, 3: 27}"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_comp = {x: x**3 for x in range(1, 4)}      # 字典推导式 → {1:1, 2:8, 3:27}\n",
    "dict_comp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_comp[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "字典键数量: 2\n",
      "字段内容: dict_items([('name', 'Alice'), ('age', 28)])\n"
     ]
    }
   ],
   "source": [
    "                                \n",
    "\n",
    "# 键的特性要求\n",
    "valid_keys = {\n",
    "    2023: \"年份\",         # 整数作为键\n",
    "    (\"geo\", \"lat\"): 35.6, # 元组作为键\n",
    "    \"email\": \"a@b.com\"    # 字符串作为键\n",
    "}\n",
    "\n",
    "# 查看字典结构\n",
    "print(\"字典键数量:\", len(person))        # 2\n",
    "print(\"字段内容:\", person.items())      # dict_items([('name', 'Alice'), ('age', 28)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "苹果库存: 15\n",
      "是否存在: True\n"
     ]
    }
   ],
   "source": [
    "# 创建测试字典\n",
    "stock = {\"apple\": 10, \"banana\": 5}\n",
    "\n",
    "# 新增元素\n",
    "stock[\"orange\"] = 8           # 新增键值对\n",
    "stock.update({\"pear\": 3})      # 批量更新\n",
    "\n",
    "# 修改元素\n",
    "stock[\"apple\"] = 15           # 直接修改\n",
    "stock.update(banana=7)        # 使用update方法\n",
    "\n",
    "# 删除元素\n",
    "del stock[\"pear\"]             # 直接删除键\n",
    "removed = stock.pop(\"banana\") # 安全删除并返回\n",
    "\n",
    "# 查询操作\n",
    "print(\"苹果库存:\", stock.get(\"apple\", 0))  # 安全获取方式\n",
    "print(\"是否存在:\", \"orange\" in stock)       # 成员检测\n",
    "\n",
    "# 防止KeyError的最佳实践\n",
    "count = stock.setdefault(\"grape\", 0)  # 不存在时创建默认条目"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "更新后的视图：\n",
      "Keys: ['red', 'green', 'blue', 'yellow']\n",
      "Values: ['#FF0000', '#00FF00', '#0000FF', '#FFFF00']\n",
      "\n",
      "遍历键值对方法对比：\n",
      "red:#FF0000\n",
      "green:#00FF00\n",
      "blue:#0000FF\n",
      "yellow:#FFFF00\n",
      "red → #FF0000\n",
      "green → #00FF00\n",
      "blue → #0000FF\n",
      "yellow → #FFFF00\n"
     ]
    }
   ],
   "source": [
    "# 原始字典\n",
    "colors = {\"red\": \"#FF0000\", \"green\": \"#00FF00\", \"blue\": \"#0000FF\"}\n",
    "\n",
    "# 获取不同视图\n",
    "keys_view = colors.keys()\n",
    "values_view = colors.values()\n",
    "items_view = colors.items()\n",
    "\n",
    "# 动态视图特性演示\n",
    "colors[\"yellow\"] = \"#FFFF00\"\n",
    "print(\"\\n更新后的视图：\")\n",
    "print(\"Keys:\", list(keys_view))    # ['red', 'green', 'blue', 'yellow']\n",
    "print(\"Values:\", list(values_view))\n",
    "\n",
    "# 遍历方法比较\n",
    "print(\"\\n遍历键值对方法对比：\")\n",
    "# 方法1：同时获取键值\n",
    "for k, v in colors.items():\n",
    "    print(f\"{k}:{v}\")\n",
    "\n",
    "# 方法2：通过键遍历\n",
    "for key in colors:\n",
    "    print(f\"{key} → {colors[key]}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'> (1, 3, 5, 7)\n",
      "['red', 'green', 'blue', 'yellow']\n"
     ]
    }
   ],
   "source": [
    "# 列表转元组\n",
    "numbers = [1, 3, 5, 7]\n",
    "tuple_num = tuple(numbers)\n",
    "print(type(tuple_num), tuple_num)  # <class 'tuple'> (1,3,5,7)\n",
    "\n",
    "# 元组转列表\n",
    "colors = (\"red\", \"green\", \"blue\")\n",
    "list_colors = list(colors)\n",
    "list_colors.append(\"yellow\")\n",
    "print(list_colors)  # ['red', 'green', 'blue', 'yellow']\n",
    "\n",
    "# 应用场景：需要保护数据结构时转为元组\n",
    "config_params = tuple([800, 600, \"admin\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# 字符串分割为列表\n",
    "csv_data = \"apple;banana;cherry\"\n",
    "fruits = csv_data.split(';')  # ['apple','banana','cherry']\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python|backend|AI\n"
     ]
    }
   ],
   "source": [
    "# 列表合并为字符串\n",
    "tags = [\"Python\", \"backend\", \"AI\"]\n",
    "joined_str = \"|\".join(tags)  # \"Python|backend|AI\"\n",
    "print(joined_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"name\": \"Zhang\", \"score\": 85}\n"
     ]
    }
   ],
   "source": [
    "# 字典转JSON字符串\n",
    "import json\n",
    "data_dict = {\"name\":\"Zhang\", \"score\":85}\n",
    "json_str = json.dumps(data_dict, ensure_ascii=False)  # {\"name\": \"Zhang\", \"score\":85}\n",
    "print(json_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
